/**
 * @p.md
 * 
 * Mailbox 模块，定义 Actor 邮箱系统的接口和基本实现
 */
import { Dispatcher } from './dispatcher';
import { MessageInvoker } from './messageInvoker';

/**
 * 邮箱接口，管理 Actor 的消息队列
 */
export interface Mailbox {
  /**
   * 投递用户消息
   * @param message 消息
   */
  postMessage(message: any): void;
  
  /**
   * 投递系统消息
   * @param message 系统消息
   */
  postSystemMessage(message: any): void;
  
  /**
   * 启动邮箱处理
   */
  start(): void;
  
  /**
   * 注册处理器
   * @param invoker 消息调用者
   * @param dispatcher 调度器
   */
  registerHandlers(invoker: MessageInvoker, dispatcher: Dispatcher): void;
}

/**
 * 消息队列接口，定义消息入队和出队操作
 */
export interface MessageQueue {
  /**
   * 入队
   * @param message 消息
   */
  enqueue(message: any): void;
  
  /**
   * 出队
   */
  dequeue(): any;
  
  /**
   * 获取队列长度
   */
  length(): number;
  
  /**
   * 判断队列是否为空
   */
  isEmpty(): boolean;
}

/**
 * 队列类型枚举
 */
export enum QueueType {
  /**
   * 无界队列，无容量限制
   */
  Unbounded = 'unbounded',
  
  /**
   * 有界队列，有容量限制
   */
  Bounded = 'bounded',
  
  /**
   * 优先级队列，按优先级排序
   */
  Priority = 'priority'
}

/**
 * 默认消息队列实现
 */
export class DefaultMessageQueue implements MessageQueue {
  private queue: any[] = [];
  
  /**
   * 消息入队
   * @param message 消息
   */
  enqueue(message: any): void {
    this.queue.push(message);
  }
  
  /**
   * 消息出队
   */
  dequeue(): any {
    return this.queue.shift();
  }
  
  /**
   * 获取队列长度
   */
  length(): number {
    return this.queue.length;
  }
  
  /**
   * 判断队列是否为空
   */
  isEmpty(): boolean {
    return this.queue.length === 0;
  }
}

/**
 * 有界消息队列实现
 */
export class BoundedMessageQueue implements MessageQueue {
  private queue: any[] = [];
  private readonly capacity: number;
  
  /**
   * 创建有界消息队列
   * @param capacity 容量上限
   */
  constructor(capacity: number) {
    this.capacity = Math.max(1, capacity);
  }
  
  /**
   * 消息入队，如果队列已满则抛出错误
   * @param message 消息
   */
  enqueue(message: any): void {
    if (this.queue.length >= this.capacity) {
      throw new Error(`Queue capacity (${this.capacity}) exceeded`);
    }
    this.queue.push(message);
  }
  
  /**
   * 消息出队
   */
  dequeue(): any {
    return this.queue.shift();
  }
  
  /**
   * 获取队列长度
   */
  length(): number {
    return this.queue.length;
  }
  
  /**
   * 判断队列是否为空
   */
  isEmpty(): boolean {
    return this.queue.length === 0;
  }
  
  /**
   * 判断队列是否已满
   */
  isFull(): boolean {
    return this.queue.length >= this.capacity;
  }
  
  /**
   * 获取队列容量
   */
  getCapacity(): number {
    return this.capacity;
  }
}

/**
 * 消息优先级接口
 */
export interface PriorityMessage {
  /**
   * 消息优先级，越小优先级越高
   */
  priority: number;
  
  /**
   * 消息内容
   */
  message: any;
}

/**
 * 优先级消息队列实现
 */
export class PriorityMessageQueue implements MessageQueue {
  private queue: PriorityMessage[] = [];
  
  /**
   * 消息入队，根据优先级排序
   * @param message 消息，如果不是 PriorityMessage 则使用默认优先级
   */
  enqueue(message: any): void {
    // 确保消息有优先级属性
    const priorityMessage: PriorityMessage = 
      typeof message === 'object' && message !== null && 'priority' in message ?
      message as PriorityMessage :
      { priority: 100, message };
    
    // 插入适当位置保持优先级排序
    let inserted = false;
    for (let i = 0; i < this.queue.length; i++) {
      if (priorityMessage.priority < this.queue[i].priority) {
        this.queue.splice(i, 0, priorityMessage);
        inserted = true;
        break;
      }
    }
    
    // 如果没有插入，添加到队尾
    if (!inserted) {
      this.queue.push(priorityMessage);
    }
  }
  
  /**
   * 消息出队，返回优先级最高的消息
   */
  dequeue(): any {
    const item = this.queue.shift();
    return item ? item.message : undefined;
  }
  
  /**
   * 获取队列长度
   */
  length(): number {
    return this.queue.length;
  }
  
  /**
   * 判断队列是否为空
   */
  isEmpty(): boolean {
    return this.queue.length === 0;
  }
} 